//1.1 let

//====1.1.1 越域
// {
//     var a = 1;
//     let b = 2;
// }
// console.log(a); // 1
// console.log(b); // ReferenceError: b is not defined

//====1.1.2 重复声明
// var 可以声明多次
// let 只能声明一次
// var m = 1
// var m = 2
// let n = 3
// let n = 4
// console.log(m) // 2
// console.log(n) // Identifier 'n' has already been declared


//====1.1.3 变量提升
// var 会变量提升
// let 不存在变量提升
// console.log(x); // undefined
// var x = 10;
// console.log(y); //ReferenceError: y is not defined
// let y = 20;

//1.2 const
// 1. 声明之后不允许改变
// 2. 一但声明必须初始化，否则会报错
// const a = 1;
// a = 3; //Uncaught TypeError: Assignment to constant variable.

//1.3解耦
//1.3.1 数组解耦
// let arr = [1, 2, 3];
// //以前我们想获取其中的值，只能通过角标。ES6 可以这样：
// const [x, y, z] = arr;// x，y，z 将与 arr 中的每个位置对应来取值
// // 然后打印
// console.log(x, y, z);

//1.3.2 对象解构
// const person = {
//     name: "jack",
//     age: 21,
//     email: "haha@atguigu.com"
// }
// 解构表达式获取值，将 person 里面每一个属性和左边对应赋值
// const {name, age, email} = person;
// 等价于下面
// const name = person.name;
// const age = person.age;
// const language = person.language;
// 可以分别打印
// console.log(name);
// console.log(age);
// console.log(language);
//扩展：如果想要将 name 的值赋值给其他变量，可以如下,nn 是新的变量名
// const {name: nn, age, language} = person;
// console.log(nn);
// console.log(age);
// console.log(language);

//1.4 链判断
// let message = null;
// 错误的写法
// const  firstName = message.body.user.firstName || 'default';

// 正确的写法
// const firstName = (message
//     && message.body
//     && message.body.user
//     && message.body.user.firstName) || 'default';
// console.log(firstName)
//这样的层层判断非常麻烦，因此 ES2020 引入了“链判断运算符”（optional chaining operator）?.，简化上面的写法
// const firstName = message?.body?.user?.firstName || 'default';
// console.log(firstName);

//1.5 参数默认值
//在 ES6 以前，我们无法给一个函数参数设置默认值，只能采用变通写法：
// function add(a, b) {
//     // 判断 b 是否为空，为空就给默认值 1
//     b = b || 1;
//     return a + b;
// }
//
// // 传一个参数
// console.log(add(10));
//
// //现在可以这么写：直接给参数写上默认值，没传就会自动使用默认值
// function add2(a, b = 1) {
//     return a + b;
// }
//
// // 传一个参数
// console.log(add2(10));

//1.6 箭头函数
//以前声明一个方法
// var print = function (obj) {
//     console.log(obj);
// }
// 可以简写为：
// let print = obj => console.log(obj);
// // 测试调用
// print(100);

// 两个参数的情况：
// let sum = function (a, b) {
//     return a + b;
// }
// // 简写为：
// //当只有一行语句，并且需要返回结果时，可以省略 {} , 结果会自动返回。
// let sum2 = (a, b) => a + b;
// //测试调用
// console.log(sum2(10, 10));//20
// // 代码不止一行，可以用`{}`括起来
// let sum3 = (a, b) => {
//     c = a + b;
//     return c;
// };
// //测试调用
// console.log(sum3(10, 20));//30

//1.7 模板字符串
// let info = "你好，我的名字是：【" + name + "】，年龄是：【" + age + "】，邮箱是：【" + email + "】";
// console.log(info)

//模板字符串的写法
// let info = `你好，我的名字是：【${name}】，年龄是：【${person.age}】，邮箱是：【${email}】`
// console.log(info);

//1.8 Promise
// 代表 异步对象，类似Java中的 CompletableFuture
// Promise 是现代 JavaScript 中异步编程的基础，是一个由异步函数返回的可以向我们指示当前操作所处的状态的对象。
// 在 Promise 返回给调用者的时候，操作往往还没有完成，但 Promise 对象可以让我们操作最终完成时对其进行处理（无论成功还是失败）
// fetch 是浏览器支持从远程获取数据的一个函数，这个函数返回的就是 Promise 对象

// 1.8.1 fetch api
// const fetchPromise = fetch(
//     "https://mdn.github.io/learning-area/javascript/apis/fetching-data/can-store/products.json"
// );
//
// console.log(fetchPromise);
//
// fetchPromise.then((response) => {
//     console.log("已收到响应：", response);
//     response.json().then((data) => {
//         console.log(data);
//     })
// });
//
// fetchPromise.catch(err => {
//     console.log("远程抓取失败", err)
// })
//
// console.log("已发送请求……");

//1.8.2 Promise状态
// promise.then();   // 操作成功以后
// promise.catch();  // 操作失败以后

// new Promise((resolve, reject)=>{
//     //某段业务
//     resolve(data); //成功以后
//     reject(err); //失败以后
// })

// function get(url){
//     return new Promise((resolve, reject)=>{
//         $.ajax({
//             url: url,
//             type: "GET",
//             success(result) {
//                 resolve(result); //成功结果
//             },
//             error(error) {
//                 reject(error); //失败结果
//             }
//         });
//     })
// }
//
// get('aaa').then(resp=>{}).catch(err=>{})

//1.9 Async 函数
// async function myFunction() {
//     //这是一个异步函数
// }

// function func1() {
//     return new Promise((resolve, reject) => {
//         let x = 101;
//         if (x % 2 === 0) {
//             resolve(x);
//         } else {
//             reject("x不是偶数");
//         }
//     })
// }


// async function fetchProducts() {
//     try {
//         // 在这一行之后，我们的函数将等待 `fetch()` 调用完成
//         // 调用 `fetch()` 将返回一个“响应”或抛出一个错误
//         const response = await fetch(
//             "https://mdn.github.io/learning-area/javascript/apis/fetching-data/can-store/products.json",
//         );
//         if (!response.ok) {
//             throw new Error(`HTTP 请求错误：${response.status}`);
//         }
//         // 在这一行之后，我们的函数将等待 `response.json()` 的调用完成
//         // `response.json()` 调用将返回 JSON 对象或抛出一个错误
//         const json = await response.json();
//         console.log('json',json)
//     } catch (error) {
//         console.error(`无法获取产品列表：${error}`);
//     }
// }
//
// fetchProducts();
